// gorpc/protocol/message.go

package protocol

import (
	"errors"
	"gorpc/codec"
	"io"
)

type Message struct {
	Header         *Header
	SerializerCode byte   // 新增字段，标识 Body 的序列化方式
	Body           []byte // 已序列化的业务数据
}

func NewMessage(ServiceMethod string) *Message {
	return &Message{
		Header: NewHeader(ServiceMethod),
	}
}

// Encode 完整消息编码（Header + Body）
func (m *Message) Encode(w io.Writer) error {

	// 先写入 Header
	m.Header.BodyLength = uint32(len(m.Body))
	if err := m.Header.Encode(w); err != nil {
		return err
	}

	// 写入序列化类型
	if _, err := w.Write([]byte{m.SerializerCode}); err != nil {
		return err
	}

	// 写入 Body
	_, err := w.Write(m.Body)
	return err
}

// Decode 完整消息解码
func (m *Message) Decode(r io.Reader) error {
	m.Header = &Header{}
	if err := m.Header.Decode(r); err != nil {
		return err
	}
	// 读取序列化类型
	serializerCode := make([]byte, 1)
	if _, err := io.ReadFull(r, serializerCode); err != nil {
		return err
	}
	m.SerializerCode = serializerCode[0]
	// 读取 Body
	m.Body = make([]byte, m.Header.BodyLength)
	_, err := io.ReadFull(r, m.Body)
	return err
}

// SerializeBody 将结构化数据序列化到Body字段
func (m *Message) SerializeBody(data interface{}, codecType codec.CodecType) error {
	// 验证编解码类型有效性
	switch codecType {
	case codec.ProtoBuffer, codec.JSON:
		// 有效类型继续处理
	default:
		return errors.New("unsupported serializer code")
	}

	// 获取编解码器实例
	c, _ := codec.NewCodec(codecType)

	// 执行序列化
	body, err := c.Encode(data)
	if err != nil {
		return err
	}

	// 存储序列化结果和类型标识
	m.SerializerCode = byte(codecType)
	m.Body = body
	return nil
}

// DeserializeBody 将Body字段反序列化为目标对象
func (m *Message) DeserializeBody(target interface{}) error {
	// 转换并验证序列化类型
	codecType := codec.CodecType(m.SerializerCode)
	switch codecType {
	case codec.ProtoBuffer, codec.JSON:
		// 有效类型继续处理
	default:
		return errors.New("unsupported serializer code")
	}

	// 获取编解码器实例
	c, _ := codec.NewCodec(codecType)

	// 执行反序列化
	return c.Decode(m.Body, target)
}
